home *** CD-ROM | disk | FTP | other *** search
/ Amiga Plus Leser 19 / Amiga Plus Leser CD 19.iso / Tools / Emulatoren / GameBoy / AmigaVGB / Z80.c < prev    next >
C/C++ Source or Header  |  2000-07-07  |  14KB  |  391 lines
  1. /** VGB: portable GameBoy emulator ***************************/
  2. /**                                                         **/
  3. /**                           Z80.c                         **/
  4. /**                                                         **/
  5. /** This file contains implementation for the GameBoy CPU.  **/
  6. /** See Z80.h for the relevant definitions. Please, note    **/
  7. /** that this code can not be used to emulate a generic Z80 **/
  8. /** because the GameBoy version of it differs from Z80 in   **/
  9. /** many ways.                                              **/
  10. /**                                                         **/
  11. /** Copyright (C) Marat Fayzullin 1994,1995,1996            **/
  12. /**     You are not allowed to distribute this software     **/
  13. /**     commercially. Please, notify me, if you make any    **/
  14. /**     changes to this file.                               **/
  15. /*************************************************************/
  16.  
  17. #include <stdio.h>
  18. #include "GB.h"
  19. #include "Tables.h"
  20.  
  21. /*** Registers ***********************************************/
  22. /*** Z80 registers and running flag.                       ***/
  23. /*************************************************************/
  24. static reg R;
  25. byte CPURunning;
  26.  
  27. /*** Interrupts **********************************************/
  28. /*** Interrupt-related variables.                          ***/
  29. /*************************************************************/
  30. int  IPeriod = 69905; /* Number of cycles between int. int-s */
  31. byte IntSync = 1;     /* 1 to generate internal interrupts   */
  32. byte IFlag = 0;       /* If IFlag==1, gen. int. and set to 0 */
  33. int  ICount;          /* Variable used to count CPU cycles   */
  34.  
  35. /*** Trace and Trap ******************************************/
  36. /*** Switches to turn tracing on and off in DEBUG mode.    ***/
  37. /*************************************************************/
  38. #ifdef DEBUG
  39. byte Trace=0;       /* Tracing is on if Trace==1  */
  40. word Trap=0xFFFF;   /* When PC==Trap, set Trace=1 */
  41. #endif
  42.  
  43. /*** TrapBadOps **********************************************/
  44. /*** When 1, print warnings of illegal Z80 instructions.   ***/
  45. /*************************************************************/
  46. byte TrapBadOps=0;
  47.  
  48.  
  49. #define S(Fl)        R.AF.B.l|=Fl
  50. #define R(Fl)        R.AF.B.l&=~(Fl)
  51. #define FLAGS(Rg,Fl) R.AF.B.l=Fl|ZSTable[Rg];
  52.  
  53. #define M_RLC(Rg)      \
  54.   R.AF.B.l=Rg>>7;Rg=(Rg<<1)|R.AF.B.l;R.AF.B.l|=ZSTable[Rg]
  55. #define M_RRC(Rg)      \
  56.   R.AF.B.l=Rg&0x01;Rg=(Rg>>1)|(R.AF.B.l<<7);R.AF.B.l|=ZSTable[Rg]
  57.  
  58. #define M_RL(Rg)       \
  59.   if(Rg&0x80)          \
  60.   {                    \
  61.     Rg=(Rg<<1)|(R.AF.B.l&C_FLAG); \
  62.     R.AF.B.l=ZSTable[Rg]|C_FLAG;  \
  63.   }                    \
  64.   else                 \
  65.   {                    \
  66.     Rg=(Rg<<1)|(R.AF.B.l&C_FLAG); \
  67.     R.AF.B.l=ZSTable[Rg];         \
  68.   }
  69. #define M_RR(Rg)       \
  70.   if(Rg&0x01)          \
  71.   {                    \
  72.     Rg=(Rg>>1)|(R.AF.B.l<<7);    \
  73.     R.AF.B.l=ZSTable[Rg]|C_FLAG; \
  74.   }                    \
  75.   else                 \
  76.   {                    \
  77.     Rg=(Rg>>1)|(R.AF.B.l<<7);    \
  78.     R.AF.B.l=ZSTable[Rg];        \
  79.   }
  80.   
  81. #define M_SLA(Rg)      \
  82.   R.AF.B.l=Rg>>7;Rg<<=1;R.AF.B.l|=ZSTable[Rg]
  83. #define M_SRA(Rg)      \
  84.   R.AF.B.l=Rg&C_FLAG;Rg=(Rg>>1)|(Rg&0x80);R.AF.B.l|=ZSTable[Rg]
  85. #define M_SLL(Rg)      \
  86.   R.AF.B.l=Rg>>7;Rg=(Rg<<1)|0x01;R.AF.B.l|=ZSTable[Rg]
  87. #define M_SRL(Rg)      \
  88.   R.AF.B.l=Rg&0x01;Rg>>=1;R.AF.B.l|=ZSTable[Rg]
  89.  
  90. #define M_BIT(Bit,Rg)  \
  91.   R.AF.B.l=(R.AF.B.l&~(N_FLAG|Z_FLAG))|H_FLAG|(Rg&(1<<Bit)? 0:Z_FLAG)
  92.  
  93. #define M_SET(Bit,Rg) Rg|=1<<Bit
  94. #define M_RES(Bit,Rg) Rg&=~(1<<Bit)
  95.  
  96. #define M_POP(Rg)      \
  97.   R.Rg.B.l=M_RDMEM(R.SP.W++);R.Rg.B.h=M_RDMEM(R.SP.W++);
  98. #define M_PUSH(Rg)     \
  99.   M_WRMEM(--R.SP.W,R.Rg.B.h);M_WRMEM(--R.SP.W,R.Rg.B.l)
  100.  
  101. #define M_CALL         \
  102.   J.B.l=M_RDMEM(R.PC.W++);J.B.h=M_RDMEM(R.PC.W++);       \
  103.   M_WRMEM(--R.SP.W,R.PC.B.h);M_WRMEM(--R.SP.W,R.PC.B.l); \
  104.   R.PC.W=J.W;ICount-=28
  105.  
  106. #define M_JP           \
  107.   J.B.l=M_RDMEM(R.PC.W++);J.B.h=M_RDMEM(R.PC.W);R.PC.W=J.W;ICount-=4
  108. #define M_JR           \
  109.   R.PC.W+=(offset)M_RDMEM(R.PC.W)+1;ICount-=4
  110. #define M_RET          \
  111.   R.PC.B.l=M_RDMEM(R.SP.W++);R.PC.B.h=M_RDMEM(R.SP.W++);ICount-=8
  112.  
  113. #define M_RST(Ad)      \
  114.   M_WRMEM(--R.SP.W,R.PC.B.h);M_WRMEM(--R.SP.W,R.PC.B.l);R.PC.W=Ad
  115.  
  116. #define M_LDWORD(Rg)   \
  117.   R.Rg.B.l=M_RDMEM(R.PC.W++);R.Rg.B.h=M_RDMEM(R.PC.W++)
  118.  
  119. #define M_ADD(Rg)      \
  120.   J.W=R.AF.B.h+Rg;     \
  121.   R.AF.B.l=J.B.h|ZSTable[J.B.l]|((R.AF.B.h^Rg^J.B.l)&H_FLAG); \
  122.   R.AF.B.h=J.B.l       
  123.  
  124. #define M_SUB(Rg)      \
  125.   J.W=R.AF.B.h-Rg;     \
  126.   R.AF.B.l=N_FLAG|-J.B.h|ZSTable[J.B.l]|((R.AF.B.h^Rg^J.B.l)&H_FLAG); \
  127.   R.AF.B.h=J.B.l
  128.  
  129. #define M_ADC(Rg)      \
  130.   J.W=R.AF.B.h+Rg+(R.AF.B.l&C_FLAG); \
  131.   R.AF.B.l=J.B.h|ZSTable[J.B.l]|((R.AF.B.h^Rg^J.B.l)&H_FLAG); \
  132.   R.AF.B.h=J.B.l
  133.  
  134. #define M_SBC(Rg)      \
  135.   J.W=R.AF.B.h-Rg-(R.AF.B.l&C_FLAG); \
  136.   R.AF.B.l=N_FLAG|-J.B.h|ZSTable[J.B.l]|((R.AF.B.h^Rg^J.B.l)&H_FLAG); \
  137.   R.AF.B.h=J.B.l
  138.  
  139. #define M_CP(Rg)       \
  140.   J.W=R.AF.B.h-Rg;     \
  141.   R.AF.B.l=N_FLAG|-J.B.h|ZSTable[J.B.l]|((R.AF.B.h^Rg^J.B.l)&H_FLAG)
  142.  
  143. #define M_AND(Rg) R.AF.B.h&=Rg;R.AF.B.l=H_FLAG|ZSTable[R.AF.B.h]
  144. #define M_OR(Rg)  R.AF.B.h|=Rg;R.AF.B.l=ZSTable[R.AF.B.h]
  145. #define M_XOR(Rg) R.AF.B.h^=Rg;R.AF.B.l=ZSTable[R.AF.B.h]
  146. #define M_IN(Rg)  Rg=DoIn(R.BC.B.l);R.AF.B.l=(R.AF.B.l&C_FLAG)|ZSTable[Rg]
  147.  
  148. #define M_INC(Rg)       \
  149.   Rg++;                 \
  150.   R.AF.B.l=(R.AF.B.l&C_FLAG)|ZSTable[Rg]|(Rg&0x0F? 0:H_FLAG)
  151.  
  152. #define M_DEC(Rg)       \
  153.   Rg--;                 \
  154.   R.AF.B.l=N_FLAG|(R.AF.B.l&C_FLAG)|ZSTable[Rg]|((Rg&0x0F)==0x0F? H_FLAG:0)
  155.  
  156. #define M_ADDW(Rg1,Rg2) \
  157.   J.W=(R.Rg1.W+R.Rg2.W)&0xFFFF;                        \
  158.   R.AF.B.l=                                            \
  159.     (R.AF.B.l&~(H_FLAG|N_FLAG|C_FLAG))|                \
  160.     ((R.Rg1.W^R.Rg2.W^J.W)&0x1000? H_FLAG:0)|          \
  161.     (((long)R.Rg1.W+(long)R.Rg2.W)&0x10000? C_FLAG:0); \
  162.   R.Rg1.W=J.W
  163.  
  164. #define M_ADCW(Rg)      \
  165.   I=R.AF.B.l&C_FLAG;J.W=(R.HL.W+R.Rg.W+I)&0xFFFF;            \
  166.   R.AF.B.l=                                                  \
  167.     (((long)R.HL.W+(long)R.Rg.W+(long)I)&0x10000? C_FLAG:0)| \
  168.     (~(R.HL.W^R.Rg.W)&(R.Rg.W^J.W)&0x8000? V_FLAG:0)|        \
  169.     ((R.HL.W^R.Rg.W^J.W)&0x1000? H_FLAG:0)|                  \
  170.     (J.W? 0:Z_FLAG)|(J.B.h&S_FLAG);                          \
  171.   R.HL.W=J.W
  172.  
  173. #define M_SBCW(Rg)      \
  174.   I=R.AF.B.l&C_FLAG;J.W=(R.HL.W-R.Rg.W-I)&0xFFFF;            \
  175.   R.AF.B.l=                                                  \
  176.     N_FLAG|                                                  \
  177.     (((long)R.HL.W-(long)R.Rg.W-(long)I)&0x10000? C_FLAG:0)| \
  178.     ((R.HL.W^R.Rg.W)&(R.HL.W^J.W)&0x8000? V_FLAG:0)|         \
  179.     ((R.HL.W^R.Rg.W^J.W)&0x1000? H_FLAG:0)|                  \
  180.     (J.W? 0:Z_FLAG)|(J.B.h&S_FLAG);                          \
  181.   R.HL.W=J.W
  182.  
  183.  
  184. enum Codes
  185. {
  186.   NOP,LD_BC_WORD,LD_xBC_A,INC_BC,INC_B,DEC_B,LD_B_BYTE,RLCA,
  187.   EX_AF_AF,ADD_HL_BC,LD_A_xBC,DEC_BC,INC_C,DEC_C,LD_C_BYTE,RRCA,
  188.   DJNZ,LD_DE_WORD,LD_xDE_A,INC_DE,INC_D,DEC_D,LD_D_BYTE,RLA,
  189.   JR,ADD_HL_DE,LD_A_xDE,DEC_DE,INC_E,DEC_E,LD_E_BYTE,RRA,
  190.   JR_NZ,LD_HL_WORD,LD_xWORD_HL,INC_HL,INC_H,DEC_H,LD_H_BYTE,DAA,
  191.   JR_Z,ADD_HL_HL,LD_HL_xWORD,DEC_HL,INC_L,DEC_L,LD_L_BYTE,CPL,
  192.   JR_NC,LD_SP_WORD,LD_xWORD_A,INC_SP,INC_xHL,DEC_xHL,LD_xHL_BYTE,SCF,
  193.   JR_C,ADD_HL_SP,LD_A_xWORD,DEC_SP,INC_A,DEC_A,LD_A_BYTE,CCF,
  194.   LD_B_B,LD_B_C,LD_B_D,LD_B_E,LD_B_H,LD_B_L,LD_B_xHL,LD_B_A,
  195.   LD_C_B,LD_C_C,LD_C_D,LD_C_E,LD_C_H,LD_C_L,LD_C_xHL,LD_C_A,
  196.   LD_D_B,LD_D_C,LD_D_D,LD_D_E,LD_D_H,LD_D_L,LD_D_xHL,LD_D_A,
  197.   LD_E_B,LD_E_C,LD_E_D,LD_E_E,LD_E_H,LD_E_L,LD_E_xHL,LD_E_A,
  198.   LD_H_B,LD_H_C,LD_H_D,LD_H_E,LD_H_H,LD_H_L,LD_H_xHL,LD_H_A,
  199.   LD_L_B,LD_L_C,LD_L_D,LD_L_E,LD_L_H,LD_L_L,LD_L_xHL,LD_L_A,
  200.   LD_xHL_B,LD_xHL_C,LD_xHL_D,LD_xHL_E,LD_xHL_H,LD_xHL_L,HALT,LD_xHL_A,
  201.   LD_A_B,LD_A_C,LD_A_D,LD_A_E,LD_A_H,LD_A_L,LD_A_xHL,LD_A_A,
  202.   ADD_B,ADD_C,ADD_D,ADD_E,ADD_H,ADD_L,ADD_xHL,ADD_A,
  203.   ADC_B,ADC_C,ADC_D,ADC_E,ADC_H,ADC_L,ADC_xHL,ADC_A,
  204.   SUB_B,SUB_C,SUB_D,SUB_E,SUB_H,SUB_L,SUB_xHL,SUB_A,
  205.   SBC_B,SBC_C,SBC_D,SBC_E,SBC_H,SBC_L,SBC_xHL,SBC_A,
  206.   AND_B,AND_C,AND_D,AND_E,AND_H,AND_L,AND_xHL,AND_A,
  207.   XOR_B,XOR_C,XOR_D,XOR_E,XOR_H,XOR_L,XOR_xHL,XOR_A,
  208.   OR_B,OR_C,OR_D,OR_E,OR_H,OR_L,OR_xHL,OR_A,
  209.   CP_B,CP_C,CP_D,CP_E,CP_H,CP_L,CP_xHL,CP_A,
  210.   RET_NZ,POP_BC,JP_NZ,JP,CALL_NZ,PUSH_BC,ADD_BYTE,RST00,
  211.   RET_Z,RET,JP_Z,PFX_CB,CALL_Z,CALL,ADC_BYTE,RST08,
  212.   RET_NC,POP_DE,JP_NC,OUTA,CALL_NC,PUSH_DE,SUB_BYTE,RST10,
  213.   RET_C,EXX,JP_C,INA,CALL_C,PFX_DD,SBC_BYTE,RST18,
  214.   RET_PO,POP_HL,JP_PO,EX_HL_xSP,CALL_PO,PUSH_HL,AND_BYTE,RST20,
  215.   RET_PE,LD_PC_HL,JP_PE,EX_DE_HL,CALL_PE,PFX_ED,XOR_BYTE,RST28,
  216.   RET_P,POP_AF,JP_P,DI,CALL_P,PUSH_AF,OR_BYTE,RST30,
  217.   RET_M,LD_SP_HL,JP_M,EI,CALL_M,PFX_FD,CP_BYTE,RST38
  218. };
  219.  
  220. enum CodesCB
  221. {
  222.   RLC_B,RLC_C,RLC_D,RLC_E,RLC_H,RLC_L,RLC_xHL,RLC_A,
  223.   RRC_B,RRC_C,RRC_D,RRC_E,RRC_H,RRC_L,RRC_xHL,RRC_A,
  224.   RL_B,RL_C,RL_D,RL_E,RL_H,RL_L,RL_xHL,RL_A,
  225.   RR_B,RR_C,RR_D,RR_E,RR_H,RR_L,RR_xHL,RR_A,
  226.   SLA_B,SLA_C,SLA_D,SLA_E,SLA_H,SLA_L,SLA_xHL,SLA_A,
  227.   SRA_B,SRA_C,SRA_D,SRA_E,SRA_H,SRA_L,SRA_xHL,SRA_A,
  228.   SLL_B,SLL_C,SLL_D,SLL_E,SLL_H,SLL_L,SLL_xHL,SLL_A,
  229.   SRL_B,SRL_C,SRL_D,SRL_E,SRL_H,SRL_L,SRL_xHL,SRL_A,
  230.   BIT0_B,BIT0_C,BIT0_D,BIT0_E,BIT0_H,BIT0_L,BIT0_xHL,BIT0_A,
  231.   BIT1_B,BIT1_C,BIT1_D,BIT1_E,BIT1_H,BIT1_L,BIT1_xHL,BIT1_A,
  232.   BIT2_B,BIT2_C,BIT2_D,BIT2_E,BIT2_H,BIT2_L,BIT2_xHL,BIT2_A,
  233.   BIT3_B,BIT3_C,BIT3_D,BIT3_E,BIT3_H,BIT3_L,BIT3_xHL,BIT3_A,
  234.   BIT4_B,BIT4_C,BIT4_D,BIT4_E,BIT4_H,BIT4_L,BIT4_xHL,BIT4_A,
  235.   BIT5_B,BIT5_C,BIT5_D,BIT5_E,BIT5_H,BIT5_L,BIT5_xHL,BIT5_A,
  236.   BIT6_B,BIT6_C,BIT6_D,BIT6_E,BIT6_H,BIT6_L,BIT6_xHL,BIT6_A,
  237.   BIT7_B,BIT7_C,BIT7_D,BIT7_E,BIT7_H,BIT7_L,BIT7_xHL,BIT7_A,
  238.   RES0_B,RES0_C,RES0_D,RES0_E,RES0_H,RES0_L,RES0_xHL,RES0_A,
  239.   RES1_B,RES1_C,RES1_D,RES1_E,RES1_H,RES1_L,RES1_xHL,RES1_A,
  240.   RES2_B,RES2_C,RES2_D,RES2_E,RES2_H,RES2_L,RES2_xHL,RES2_A,
  241.   RES3_B,RES3_C,RES3_D,RES3_E,RES3_H,RES3_L,RES3_xHL,RES3_A,
  242.   RES4_B,RES4_C,RES4_D,RES4_E,RES4_H,RES4_L,RES4_xHL,RES4_A,
  243.   RES5_B,RES5_C,RES5_D,RES5_E,RES5_H,RES5_L,RES5_xHL,RES5_A,
  244.   RES6_B,RES6_C,RES6_D,RES6_E,RES6_H,RES6_L,RES6_xHL,RES6_A,
  245.   RES7_B,RES7_C,RES7_D,RES7_E,RES7_H,RES7_L,RES7_xHL,RES7_A,  
  246.   SET0_B,SET0_C,SET0_D,SET0_E,SET0_H,SET0_L,SET0_xHL,SET0_A,
  247.   SET1_B,SET1_C,SET1_D,SET1_E,SET1_H,SET1_L,SET1_xHL,SET1_A,
  248.   SET2_B,SET2_C,SET2_D,SET2_E,SET2_H,SET2_L,SET2_xHL,SET2_A,
  249.   SET3_B,SET3_C,SET3_D,SET3_E,SET3_H,SET3_L,SET3_xHL,SET3_A,
  250.   SET4_B,SET4_C,SET4_D,SET4_E,SET4_H,SET4_L,SET4_xHL,SET4_A,
  251.   SET5_B,SET5_C,SET5_D,SET5_E,SET5_H,SET5_L,SET5_xHL,SET5_A,
  252.   SET6_B,SET6_C,SET6_D,SET6_E,SET6_H,SET6_L,SET6_xHL,SET6_A,
  253.   SET7_B,SET7_C,SET7_D,SET7_E,SET7_H,SET7_L,SET7_xHL,SET7_A
  254. };
  255.  
  256.  
  257. void CodesCB(void)
  258. {
  259.   static byte CyclesCB[256] =
  260.   {
  261.      8, 8, 8, 8, 8, 8,16, 8, 8, 8, 8, 8, 8, 8,16, 8,
  262.      8, 8, 8, 8, 8, 8,16, 8, 8, 8, 8, 8, 8, 8,16, 8,
  263.      8, 8, 8, 8, 8, 8,16, 8, 8, 8, 8, 8, 8, 8,16, 8,
  264.      8, 8, 8, 8, 8, 8,16, 8, 8, 8, 8, 8, 8, 8,16, 8,
  265.      8, 8, 8, 8, 8, 8,16, 8, 8, 8, 8, 8, 8, 8,16, 8,
  266.      8, 8, 8, 8, 8, 8,16, 8, 8, 8, 8, 8, 8, 8,16, 8,
  267.      8, 8, 8, 8, 8, 8,16, 8, 8, 8, 8, 8, 8, 8,16, 8,
  268.      8, 8, 8, 8, 8, 8,16, 8, 8, 8, 8, 8, 8, 8,16, 8,
  269.      8, 8, 8, 8, 8, 8,16, 8, 8, 8, 8, 8, 8, 8,16, 8,
  270.      8, 8, 8, 8, 8, 8,16, 8, 8, 8, 8, 8, 8, 8,16, 8,
  271.      8, 8, 8, 8, 8, 8,16, 8, 8, 8, 8, 8, 8, 8,16, 8,
  272.      8, 8, 8, 8, 8, 8,16, 8, 8, 8, 8, 8, 8, 8,16, 8,
  273.      8, 8, 8, 8, 8, 8,16, 8, 8, 8, 8, 8, 8, 8,16, 8,
  274.      8, 8, 8, 8, 8, 8,16, 8, 8, 8, 8, 8, 8, 8,16, 8,
  275.      8, 8, 8, 8, 8, 8,16, 8, 8, 8, 8, 8, 8, 8,16, 8,
  276.      8, 8, 8, 8, 8, 8,16, 8, 8, 8, 8, 8, 8, 8,16, 8
  277.   };
  278.  
  279.   register byte I;
  280.  
  281.   I=M_RDMEM(R.PC.W++);
  282.   ICount-=CyclesCB[I];
  283.   switch(I)
  284.   {
  285. #include "CodesCB.h"
  286.     default:
  287.       ICount-=4;
  288.       if(TrapBadOps)
  289.         printf
  290.         (   
  291.           "Unrecognized instruction: CB %X at PC=%hX\n",
  292.           M_RDMEM(R.PC.W-1),R.PC.W-2
  293.         );
  294.   }
  295. }
  296.  
  297.  
  298. /*** Reset Z80 registers: *********************************/
  299. /*** This function can be used to reset the register    ***/
  300. /*** file before starting execution with Z80(). It sets ***/
  301. /*** the registers to their initial values.             ***/
  302. /**********************************************************/
  303. void ResetZ80(reg *Regs)
  304. {
  305.   Regs->PC.W=0x0100;Regs->SP.W=0xF000;
  306.   Regs->AF.W=Regs->BC.W=Regs->DE.W=Regs->HL.W=0x0000;
  307.   Regs->I=0x00;Regs->IFF=0x00;
  308. }
  309.  
  310. /*** Interpret Z80 code: **********************************/
  311. /*** Registers have initial values from Regs. PC value  ***/
  312. /*** at which emulation stopped is returned by this     ***/
  313. /*** function.                                          ***/
  314. /**********************************************************/
  315. word Z80(reg Regs)
  316. {
  317.   static byte Cycles[256] =
  318.   {
  319.      4,12, 8, 8, 4, 4, 8, 4,20, 8, 8, 8, 4, 4, 8, 4,
  320.      4,12, 8, 8, 4, 4, 8, 4, 8, 8, 8, 8, 4, 4, 8, 4,
  321.      8,12, 8, 8, 4, 4, 8, 4, 8, 8, 8, 8, 4, 4, 8, 4,
  322.      8,12, 8, 8,12,12,12, 4, 8, 8, 8, 8, 4, 4, 8, 4,
  323.      4, 4, 4, 4, 4, 4, 8, 4, 4, 4, 4, 4, 4, 4, 8, 4,
  324.      4, 4, 4, 4, 4, 4, 8, 4, 4, 4, 4, 4, 4, 4, 8, 4,
  325.      4, 4, 4, 4, 4, 4, 8, 4, 4, 4, 4, 4, 4, 4, 8, 4,
  326.      8, 8, 8, 8, 8, 8, 4, 8, 4, 4, 4, 4, 4, 4, 8, 4,
  327.      4, 4, 4, 4, 4, 4, 8, 4, 4, 4, 4, 4, 4, 4, 8, 4,
  328.      4, 4, 4, 4, 4, 4, 8, 4, 4, 4, 4, 4, 4, 4, 8, 4,
  329.      4, 4, 4, 4, 4, 4, 8, 4, 4, 4, 4, 4, 4, 4, 8, 4,
  330.      4, 4, 4, 4, 4, 4, 8, 4, 4, 4, 4, 4, 4, 4, 8, 4,
  331.      8,12,12,12,12,16, 8,32, 8, 8,12, 0,12,12, 8,32,
  332.      8,12,12, 0,12,16, 8,32, 8, 8,12, 0,12, 0, 8,32,
  333.     12,12, 8, 0, 0,16, 8,32,16, 4,16, 0, 0, 0, 8,32,
  334.     12,12, 8, 4, 0,16, 8,32,12, 8,16, 4, 0, 0, 8,32
  335.   };
  336.  
  337.   register byte I;
  338.   register pair J;
  339.  
  340.   R=Regs;ICount=IPeriod;CPURunning=1;
  341.  
  342.   for(;;)
  343.   {
  344. #ifdef DEBUG
  345.     if(R.PC.W==Trap) Trace=1;  /*** Turn tracing on if trapped ***/
  346.     if(Trace) Debug(&R);       /*** Call single-step debugger  ***/
  347. #endif
  348.  
  349.     I=M_RDMEM(R.PC.W++);
  350.     ICount-=Cycles[I];
  351.     switch(I)
  352.     {
  353. #include "Codes.h"
  354.       case PFX_CB:
  355.         CodesCB();break;
  356.       case 0x10:
  357.       case HALT:
  358.         R.PC.W--;R.IFF|=0x80;break;
  359.       default:
  360.         ICount-=4;
  361.         if(TrapBadOps)
  362.           printf
  363.           (
  364.             "Unrecognized instruction: %X at PC=%hX\n",
  365.             M_RDMEM(R.PC.W-1),R.PC.W-1
  366.           );
  367.     }
  368.  
  369.     if(ICount<=0) 
  370.     {
  371.       ICount+=IPeriod;
  372.       if(!CPURunning) break;
  373.       if(IntSync) IFlag=1;
  374.     }
  375.  
  376.     if(IFlag)
  377.     {
  378.       IFlag=0;J.W=Interrupt();
  379.       if((J.W!=0xFFFF)&&(R.IFF&0x81))
  380.       {
  381.         if(R.IFF&0x80) R.PC.W++;
  382.         IFLAGS&=~IMask;IMask=0x00;
  383.         R.IFF&=0x7E;
  384.         M_PUSH(PC);R.PC.W=J.W;
  385.       }
  386.     }  
  387.   }
  388.  
  389.   return(R.PC.W);
  390. }
  391.